Managing power consumption has always been important for computers. For example, power consumption has always been particularly important for portable computers and other electronic devices powered by batteries. Because batteries only store a finite amount of energy, designers of battery-operated computers have always considered power consumption to be an important design constraint. Portable computers can operate for longer periods of time without recharging the batteries when power consumption is effectively managed. This cognizance of power consumption has been extended to the development of desktop and server data processing systems (e.g., computer systems), shifting the focus from more traditional aspects such as the volume of data stored, the speed at which operations are completed, or the flexibility of the types of operations which may be performed.
Though non-portable data processing systems do not run out of battery power, designing such systems to reduce power consumption results in cost savings and in the conservation of natural resources. Energy efficient systems enjoy a reduction in operating cost because less energy need be purchased to power the systems. Conserving natural resources is an added benefit of the lower power requirements of energy efficient systems. Systems that require less power require fewer natural resources to be converted into energy. Additionally, in the larger data processing system context, a reduction in power consumption may be necessary to achieve eligibility for certain environmental impact standards or labels such as the “Energy Star” rating system established by the United States Department of Energy and the Environmental Protection Agency.
Another benefit provided by energy efficient systems is a reduction in heat production. The amount of heat produced by a computer system is proportional to power consumption. Thus, energy efficient systems produce less heat because they consume less power. Furthermore, systems producing less heat may be even more energy efficient because less power is required to operate the cooling systems used to dissipate the heat produced by the systems. Energy efficient systems pose fewer design constraints related to heat issues. In the context of larger data processing systems, heat issues, and the associated cooling requirements, may be more of a concern than power consumption iteself.
In conventional data processing systems, power consumption may be reduced by reducing the voltage applied to idle or underutilized portions of the system, such as processors, processing cores, or processing core units. The frequency of a clock signal applied to such portions may also be adjusted to reduce power consumption. Other techniques involve completely or partially shutting down such portions of the system until the portions are needed again.
Power management strategies, such as those identified above, are generally governed by a power management policy. Contemporary power management policies are generally configured to attempt to reduce power consumption with a minimal impact on performance. Thus, power management policies generally make system resources available to any task ready to execute, regardless of the importance of the task. One exception to the general practices is a “power capping” power management policy. The power capping policy adjusts performance as needed in order to satisfy a maximum threshold of power consumption. However, a power capping policy is not generally flexible enough to effectively reduce power consumption while still having minimal effect on performance. Power management policies may also change over time in response to changes in power or performance constraints.
Power management strategies, however, are usually only effectively employed when a portion of the system is underutilized. Contemporary data processing systems, particularly servers, frequently run background tasks such as batch jobs or system maintenance tasks. These background tasks may prevent portions of a system from being idle, limiting the effectiveness of the strategies employed in power management policies, as the system is kept busy performing work, which is necessary, though not necessarily critical in nature, from the standpoint of performance.
Tasks that execute in a computer are often assigned a priority, which is often used to balance work across the computer, e.g., by scheduling tasks according to their relative priorities. In many cases, however, there is a difference between whether a task executing within a computer system is of high priority from a workload-balancing standpoint and whether the task is critical from a performance or power management standpoint. High priority tasks generally have access to more system resources than lower priority tasks. But, high priority tasks may not have firm response time constraints. For example, after a user in a web application creates an order, one task in the system may be responsible for sending an email confirmation message. This task may be high priority, since it is more important than lower priority background tasks. But it may have a low criticality, since an extra delay before the email message is sent would be acceptable. Thus, degrading or delaying the performance of this task in order to reduce power consumption may be acceptable in some scenarios.
In contrast, some more performance critical tasks may have rigid response time constraints that must be satisfied, and it would be considered unacceptable to degrade or delay performance of these tasks in order to reduce power consumption. Indeed, some performance critical tasks may be granted low priorities irrespective of their high criticality from a performance standpoint. For example, a database application may include a task to perform certain maintenance operations in the background. This task would be considered low-priority, since user requests would take precedence over this maintenance activity. But the task may have medium- or high-criticality, because it would be unacceptable to delay these maintenance operations indefinitely. As a result, the priority assigned to a task typically cannot be relied upon as a reliable predictor of the criticality of the task from the standpoint of performance and power management.
In addition, the relative criticality among tasks, system performance requirements, and system power consumption requirements may change over time. For example, a Java Just-In-Time (JIT) Compiler typically asynchronously compiles frequently executed code at increasingly higher optimization levels. The code compiled by the JIT Compiler may be executed by applications on a Java Virtual Machine (JVM). Tasks associated with the JIT Compiler may be critical during the startup of the JVM when code is initially loaded and interpreted. At this startup phase, the code optimizations performed by the JIT Compiler may be critical because large performance gains are realized by optimizing the un-optimized code. But, tasks associated with the JIT Compiler may become non-critical when the performance gains become marginal after most of the frequently executed code has been compiled at a low optimization level and the JIT Compiler is only performing further optimization.
What is needed, therefore, is an improved method to manage power consumption in a computer system that is better able to account for the critical nature of tasks executing in the system.